(deftemplate actiune(multislot ora) (slot descriere))
(deftemplate intrare (slot val))
(deftemplate iesire (slot val))
(deftemplate actiunibaie (slot val))
(deftemplate actiunibucatarie (slot val))
(deftemplate actiunicamera (slot val))
(deftemplate servici (slot val))
(deftemplate ceva(slot val))

(defglobal ?*ultim* = nimic)
(defglobal ?*intraultim* = nimic)

(defglobal ?*succes* = false)

(defglobal ?*data* = (new java.util.Date))
(defglobal ?*rand* = (new java.util.Random))

/*definirea orei si minutului curent si a orei si minutului de trezire*/
(defglobal ?*ora* = 2)
(defglobal ?*min* = 2)
(defglobal ?*oratrezire* = 3)
(defglobal ?*mintrezire* = 3)

(defglobal ?*oraculcare* = 0)

/*variabile ce definesc daca un electrocasnic este utilizat sau nu*/
(defglobal ?*bec* = false)
(defglobal ?*aragaz* = false)
(defglobal ?*dvdplayer* = false)
(defglobal ?*televizor* = false)
(defglobal ?*calculator* = false)
(defglobal ?*aer_conditionat* = false)

/*verifica daca este intr-o anumita incapere*/
(defglobal ?*camera* = false)
(defglobal ?*bucatarie* = false)
(defglobal ?*baie* = false)

/*variabile definite pentru a nu putea merge la scoala sau la servici de mai multe ori*/
(defglobal ?*nservici* = 0)
(defglobal ?*nscoala* = 0)

(defglobal ?*ndus* = 0)
(defglobal ?*nmancare* = 0)
(defglobal ?*ntoaleta* = 0)
(defglobal ?*nhaine* = 0)
(defglobal ?*nbaie* = 0)
(defglobal ?*nvase* = 0)

(defglobal ?*orahaine* = 0)

/*variabila pt random*/
(defglobal ?*x* = 3)

(deffunction ia_ora ()
    (return (call ?*data* getHours )))

(deffunction ia_min ()
    (return (call ?*data* getMinutes )))

(deffunction seteaza_ora (?x)
    (call ?*data* setHours ?x))

(deffunction seteaza_min (?x)
    (call ?*data* setMinutes ?x))

(deffunction schimba_ora (?min)
    (call ?*data* setMinutes (+ ?min (ia_min)) ))

(deffunction myrandom (?i)
    (call ?*rand* nextInt ?i)
    )
/*seteaza ora de trezire*/
(deffunction sethour (?i)
    (if (eq ?i 0) 
        then (seteaza_ora 6) (seteaza_min 0)
        else (if (eq ?i 1) 
        then (seteaza_ora 6) (seteaza_min 30)
        else (if (eq ?i 2) 
        then (seteaza_ora 7) (seteaza_min 0)
        else (if (eq ?i 3) 
        then (seteaza_ora 7) (seteaza_min 30)
        else (if (eq ?i 4) 
        then (seteaza_ora 8) (seteaza_min 0)
        else (if (eq ?i 5) 
        then (seteaza_ora 8) (seteaza_min 30)
        else (if (eq ?i 6) 
        then (seteaza_ora 9) (seteaza_min 0))))))))
    )

(deffunction sethour2 (?i)
    (if (eq ?i 0) 
        then (bind ?*oraculcare* 21)
        else (if (eq ?i 1) 
        then (bind ?*oraculcare* 22)
        else (if (eq ?i 2) 
        then (bind ?*oraculcare* 23)
        else (if (eq ?i 3) 
        then (bind ?*oraculcare* 0))))))

(assert (actiune (ora "noaptea") (descriere "toata lumea doarme")))

/*seteaza ora la care se trezeste*/
(defrule alege_ora_trezire
    (declare (salience 100))
    ?id <- (actiune (ora "noaptea") (descriere "toata lumea doarme"))
    =>
    (retract ?id)
    (bind ?*x* (myrandom 7))
    (sethour ?*x*)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*oratrezire* ?*ora*)
    (bind ?*mintrezire* ?*min*)
    (bind ?*camera* true)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se trezeste")))
    )
/*se trezeste si aprinde becul*/
(defrule trezire
    (actiune (ora ?*ora* ?*min*) (descriere "se trezeste"))
    =>
    (printout t "se trezeste la ora " ?*ora*  ":" ?*min* crlf)
    (assert (actiune (ora "ora") (descriere "aprinde becul")))
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    )
/*(defrule alege_ora_culcare
    (declare (salience 90))
    ?id <- (actiune (ora "noaptea") (descriere "ora de culcare"))
    =>
    (retract ?id)
    (bind ?*x* (myrandom 3))
    (sethour2 ?*x*)
    (assert (actiune (ora ?*oraculcare*) (descriere "se culca")))
    )*/
(defrule culca
    (actiune (ora ?*ora* ?*min*) (descriere ?desc))
    (test (eq ?*ora* 22))
    =>
    (assert (actiune (ora "noaptea") (descriere "ora de culcare"))))
/*nu merge - stinge becul si se pune sa doarma*/
(defrule culcare
    (actiune (ora "noaptea") (descriere "ora de culcare"))
    =>
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se pune la culcare")))
    (printout t "stinge tot la ora "?*ora* ":"?*min* crlf)
    (printout t "se pune la culcare la ora "?*ora* ":"?*min* crlf)
    (exit)
    )
/*aprinde bec*/
(defrule aprinde_bec    
    (declare (salience 90))
    ?id<-(actiune (ora "ora") (descriere "aprinde becul"))
    (test (eq ?*bec* false))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "aprinde becul")))
    (assert (iesire (val 1)))
    (printout t "aprinde becul la ora "?*ora* ":"?*min* crlf)
    (bind ?*bec* true)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
/*stringe bec*/
(defrule stinge_bec     
    (declare (salience 90))
      ?id<-(actiune (ora "ora") (descriere "stinge becul")) 
    (test (eq ?*bec* true))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "stinge becul")))
    (bind ?*bec* false)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    
    )
/*alege incaperea in care sa intre*/
(defrule intra
    (declare (salience 80))
    ?id<-(ceva (val 0))
    =>
    (retract ?id)
    (bind ?*x* (myrandom 3))
    (assert (intrare (val ?*x*)))
    (bind ?*bucatarie* false)
    (bind ?*camera* false)
    (bind ?*baie* false)
    (bind ?*succes* false)
    )
/*(defrule esuazaintrare
    (declare (salience 10))
    (or ?id<-(intrare (val 0))
        ?id<-(intrare (val 1))
        ?id<-(intrare (val 2)))
    (test (eq ?*succes* false))
    =>
    (retract ?id)
    (assert (ceva (val 0)))
    )*/
/*intra in bucatarie*/
(defrule intra_bucatarie
    (declare (salience 20))
    ?id<-(intrare (val 0))
   /* (test (neq ?*intraultim* bucatarie))
    (test (eq ?*succes* false))*/
    =>
   /* (bind ?*succes* true) */
    (assert (actiune (ora ?*ora* ?*min*) (descriere "intra in bucatarie")))
    (retract ?id)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*bucatarie* true)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (assert (actiune (ora "ora") (descriere "aprinde becul")))
    /*(bind ?*intraultim* bucatarie)*/
    (printout t "intra in bucatarie la ora "?*ora* ":"?*min* crlf)
    )
/*intra in baie*/
(defrule intra_baie
    (declare (salience 20))
    ?id<-(intrare (val 1))
    /*(test (neq ?*intraultim* baie))
    (test (eq ?*succes* false))*/
    =>
    /*(bind ?*succes* true)*/
    (retract ?id)
    /*(bind ?*intraultim* baie)*/
    (assert (actiune (ora ?*ora* ?*min*) (descriere "intra in baie")))
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*baie* true)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (assert (actiune (ora "ora") (descriere "aprinde becul")))
    (printout t "intra in baie la ora "?*ora* ":"?*min* crlf)
    )
/*intra in camera*/
(defrule intra_camera
    (declare (salience 20))
    ?id<-(intrare (val 2))
   /* (test (neq ?*intraultim* camera))
    (test (eq ?*succes* false))*/
    =>
    /*(bind ?*succes* true)*/
    (retract ?id)
    /*(bind ?*intraultim* camera)*/
    (assert (actiune (ora ?*ora* ?*min*) (descriere "intra in camera")))
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*camera* true)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (assert (actiune (ora "ora") (descriere "aprinde becul")))
    (printout t "intra in camera la ora "?*ora* ":"?*min* crlf)
    )
/*alege ce face in incapere: iese sau face ceva*/
(defrule alegeincamera
    (declare (salience 100))
    ?id<-(actiune (ora "ora") (descriere "alege iesire"))
    =>
    (retract ?id)
    (bind ?*x* (myrandom 2))
    (assert (iesire (val ?*x*)))
    )
(defrule iese
    ?id<-(iesire (val 0))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "iese")))
    )
/*iese din bucatarie*/
(defrule iese_bucatarie
    ?id<-(actiune (ora "ora") (descriere "iese"))
    (test (eq ?*bucatarie* true))
    =>
    (retract ?id)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*bucatarie* false)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "iese din bucatarie")))
    (assert (actiune (ora "ora") (descriere "stinge becul")))    
    (assert (actiune (ora "ora") (descriere "alege ceva")))
    (printout t "iese din bucatarie la ora "?*ora* ":"?*min* crlf)
    (printout t "stinge becul la ora "?*ora* ":"?*min* crlf)
    )
/*iese din baie*/
(defrule iese_baie
    ?id<-(actiune (ora "ora") (descriere "iese"))
    (test (eq ?*baie* true))
    =>
    (retract ?id)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*baie* false)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "iese din baie")))
    (assert (actiune (ora "ora") (descriere "alege ceva")))
    (assert (actiune (ora "ora") (descriere "stinge becul")))
    (printout t "iese din baie la ora "?*ora* ":"?*min* crlf)
    (printout t "stinge becul la ora "?*ora* ":"?*min* crlf)
    )
/*iese din camera*/
(defrule iese_camera
    ?id<-(actiune (ora "ora") (descriere "iese"))
    (test (eq ?*camera* true))
    =>
    (retract ?id)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*camera* false)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "iese din camera")))
    (assert (actiune (ora "ora") (descriere "alege ceva")))
    (assert (actiune (ora "ora") (descriere "stinge becul")))
    (printout t "iese din camera la ora "?*ora* ":"?*min* crlf)
    (printout t "stinge becul la ora "?*ora* ":"?*min* crlf)
    )
/*alege intre a intra intr-o incapere sau a iesi din casa*/
(defrule ceva
    (declare (salience 80))
    ?id<-(actiune (ora "ora") (descriere "alege ceva"))
    =>
    (retract ?id)
    (bind ?*x* (myrandom 1))
    (assert (ceva (val ?*x*)))
    )
/*alege unde sa plece*/
(defrule pleaca
    (declare (salience 80))
    ?id<-(ceva (val 1))
    =>
    (retract ?id)
    (bind ?*x* (myrandom 3))
    (assert (servici (val ?*x*)))
    (bind ?*succes* false)
    )
(defrule esuazaplecare
    (declare (salience 10))
    (or ?id<-(servici (val 0))
        ?id<-(servici (val 1)))
    (test (eq ?*succes* false))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "alege ceva")))
    (printout t "fail leave" crlf)
    )
/*merge la serciciu*/
(defrule merge_servici
    (declare (salience 20))
    ?id<-(servici (val 0))
    (test (eq ?*nservici* 0))
    (test (eq ?*nscoala* 0))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "merge la servici")))
    (printout t "merge la servici la ora "?*ora* ":"?*min* crlf)
    (bind ?*nservici* 1)
    (bind ?*nscoala* 1)
    (schimba_ora 540)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))    
    (assert (actiune (ora ?*ora* ?*min*) (descriere "vine de la servici")))
    (assert (ceva (val 0)))
    (printout t "vine de la servici la ora "?*ora* ":"?*min* crlf)
    )
/*merge la scoala*/
(defrule merge_scoala
    (declare (salience 20))
    ?id<-(servici (val 1))
    (test (eq ?*nscoala* 0))
    (test (eq ?*nservici* 0))
    (test (eq ?*ora* 7))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "merge la scoala")))
    (printout t "merge la scoala la ora "?*ora* ":"?*min* crlf)
    (bind ?*nscoala* 1)
    (bind ?*nservici* 1)
    (schimba_ora 360)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "vine de la scoala")))
    (assert (ceva (val 0)))
    (printout t "vine de la scoala la ora "?*ora* ":"?*min* crlf)
    )
/*merge afara*/
(defrule merge_afara
    (declare (salience 20))
    ?id<-(servici (val 2))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "merge afara")))
    (printout t "merge afara la ora "?*ora* ":"?*min* crlf)
    (schimba_ora 30)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "vine de afara")))
    (assert (ceva (val 0)))
    (printout t "vine de afara la ora "?*ora* ":"?*min* crlf)
    )
/*alege sa faca o actiune*/
(defrule alegeact
    ?id<-(iesire (val 1))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "actiune")))
    (bind ?*succes* false)
    )
/*alege ce actiune sa faca in baie*/
(defrule esuazabaie
    (declare (salience 10))
    (or ?id<-(actiune (ora "ora") (descriere "toaleta"))
        ?id<-(actiune (ora "ora") (descriere "dus"))
        ?id<-(actiune (ora "ora") (descriere "haine"))
        ?id<-(actiune (ora "ora") (descriere "curatenie"))
        ?id<-(actiune (ora "ora") (descriere "chiuveta"))
        )
    (test (eq ?*succes* false))
    =>
    (retract ?id)
    (assert (iesire (val 1)))
    )
/*alege ce actiune sa faca in baie*/
(defrule esuazabucatarie
    (declare (salience 10))
    (or ?id<-(actiune (ora "ora") (descriere "vase"))
        ?id<-(actiune (ora "ora") (descriere "mananca"))
        ?id<-(actiune (ora "ora") (descriere "microunde"))
        ?id<-(actiune (ora "ora") (descriere "aragaz"))
        ?id<-(actiune (ora "ora") (descriere "filtru"))
        ?id<-(actiune (ora "ora") (descriere "paine"))
        ?id<-(actiune (ora "ora") (descriere "sandwich"))
        ?id<-(actiune (ora "ora") (descriere "mixer"))
        )
    (test (eq ?*succes* false))
    =>
    (retract ?id)
    (assert (iesire (val 1)))
    )
/*alege ce actiune sa faca in baie*/
(defrule esuazacamera
    (declare (salience 10))
    (or ?id<-(actiune (ora "ora") (descriere "porneste dvd"))
        ?id<-(actiune (ora "ora") (descriere "opreste dvd"))
        ?id<-(actiune (ora "ora") (descriere "porneste tv"))
        ?id<-(actiune (ora "ora") (descriere "opreste tv"))
        ?id<-(actiune (ora "ora") (descriere "porneste calculator"))
        ?id<-(actiune (ora "ora") (descriere "opreste calculator"))
        ?id<-(actiune (ora "ora") (descriere "porneste aer conditionat"))
        ?id<-(actiune (ora "ora") (descriere "opreste aer conditionat"))
        ?id<-(actiune (ora "ora") (descriere "sta"))
        ?id<-(actiune (ora "ora") (descriere "sta la calculator"))
        ?id<-(actiune (ora "ora") (descriere "uita tv"))
        ?id<-(actiune (ora "ora") (descriere "aspirator"))
        )
    (test (eq ?*succes* false))
    =>
    (retract ?id)
    (assert (iesire (val 1)))
    )
(defrule alege_actiune_baie 
    (declare (salience 80)) 
    ?id<-(actiune (ora "ora") (descriere "actiune"))
    (test (eq ?*baie* true))
    =>    
    (retract ?id)
    (bind ?*x* (myrandom 5))
    (assert (actiunibaie (val ?*x*)))
    (bind ?*succes* false)
    )
/*alege ce actiune sa faca in bucatarie*/
(defrule alege_actiune_bucatarie 
    (declare (salience 80)) 
    ?id<-(actiune (ora "ora") (descriere "actiune"))
    (test (eq ?*bucatarie* true))
    =>    
    (retract ?id)
    (bind ?*x* (myrandom 8))
    (assert (actiunibucatarie (val ?*x*)))
    (bind ?*succes* false)
    )
/*alege ce actiune sa faca in camera*/
(defrule alege_actiune_camera
    (declare (salience 80)) 
    ?id<-(actiune (ora "ora") (descriere "actiune"))
    (test (eq ?*camera* true))
    =>    
    (retract ?id)
    (bind ?*x* (myrandom 12))
    (assert (actiunicamera (val ?*x*)))
    (bind ?*succes* false)
    )
(defrule alegetoaleta
    ?id<-(actiunibaie (val 0))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "toaleta")))
    )
(defrule foloseste_toaleta
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "toaleta"))
    (test (neq ?*ntoaleta* 5))
    (test (neq ?*ultim* toaleta))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* chiuveta)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste toaleta")))
    (printout t "foloseste toaleta la ora "?*ora* ":"?*min* crlf)
    (schimba_ora 5)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min)) 
    (bind ?*ntoaleta* (+ 1 ?*ntoaleta*))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se spala la chiuveta")))
    (printout t "se spala la chiuveta la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    )
(defrule alegehiuveta
    ?id<-(actiunibaie (val 1))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "chiuveta")))
    )
(defrule spala_chiuveta
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "chiuveta"))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se spala la chiuveta")))
    (printout t "se spala la chiuveta la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 5)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegedus
    ?id<-(actiunibaie (val 2))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "dus")))
    )
(defrule spala_dus
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "dus"))
    (test (neq ?*ndus* 2))
    (test (neq ?*ultim* dus))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* dus)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se spala la dus")))
    (printout t "se spala la dus la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 20)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*ndus* (+ 1 ?*ndus*))
    )
(defrule alegehaine
    ?id<-(actiunibaie (val 3))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "haine")))
    )
(defrule spala_haine
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "haine"))
    (test (neq ?*nhaine* 3))
    (test (neq ?*ultim* haine))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* haine)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "spala haine")))
    (printout t "spala haine la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 5)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*orahaine* ?*ora*)
    (bind ?*nhaine* (+ 1 ?*nhaine*))
    )
(defrule alegebaie
    ?id<-(actiunibaie (val 4))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "curatenie")))
    )
(defrule curata_baie
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "curatenie"))
    (test (eq ?*nbaie* 0))
    (test (neq ?*ultim* baie))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* baie)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "face curat in baie")))
    (printout t "face curat in baie la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 30)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*nbaie* 1)
    )
(defrule alegemicrounde
    ?id<-(actiunibucatarie (val 0))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "microunde")))
    )
(defrule porneste_cuptor_microunde
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "microunde"))
    (test (neq ?*ultim* microunde))
    =>
    (bind ?*ultim* microunde)
    (bind ?*succes* true)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste cuptorul cu microunde")))
    (printout t "foloseste cuptorul cu microunde la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 2)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegearagaz
    ?id<-(actiunibucatarie (val 1))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "aragaz")))
    )
(defrule porneste_aragaz   
    (declare (salience 20))
     ?id<-(actiune (ora "ora") (descriere "aragaz"))
    (test (neq ?*ultim* aragaz))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* aragaz)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste aragazul")))
    (printout t "foloseste aragazul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 15)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegefiltru
    ?id<-(actiunibucatarie (val 2))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "filtru")))
    )
(defrule porneste_filtru_cafea
    (declare (salience 20))   
     ?id<-(actiune (ora "ora") (descriere "filtru"))
    (test (neq ?*ultim* filtru))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* filtru)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste filtrul de cafea")))
    (printout t "foloseste filtrul de cafea la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 10)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegevase
    ?id<-(actiunibucatarie (val 3))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "vase")))
    )
(defrule porneste_masina_spalat_vase
    (declare (salience 20))
     ?id<-(actiune (ora "ora") (descriere "vase"))
    (test (neq ?*nvase* ?*nmancare*))
    (test (neq ?*ultim* vase))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* vase)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "spala vasele")))
    (printout t "spala vasele la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 15)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*nvase* (+ 1 ?*nvase*))
    )
(defrule alegepaine
    ?id<-(actiunibucatarie (val 4))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "paine")))
    )
(defrule porneste_prajitor_paine
    (declare (salience 20))
     ?id<-(actiune (ora "ora") (descriere "paine"))
    (test (neq ?*ultim* paine))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* paine)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste prajitorul de paine")))
    (printout t "foloseste prajitorul de paine la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 5)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegesandwich
    ?id<-(actiunibucatarie (val 5))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "sandwich")))
    )
(defrule porneste_sandwichmaker
    (declare (salience 20))
     ?id<-(actiune (ora "ora") (descriere "sandwich"))
    (test (neq ?*ultim* sandwich))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* sandwich)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste sandwich-makerul")))
    (printout t "foloseste sandwich-makerul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 15)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegemixer
    ?id<-(actiunibucatarie (val 6))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "mixer")))
    )
(defrule porneste_mixer_blender
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "mixer"))
    (test (neq ?*ultim* mixer))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* mixer)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste mixerul/blenderul")))
    (printout t "foloseste mixerul/blenderul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 10)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegedvdp
    ?id<-(actiunicamera (val 0))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "porneste dvd")))
    )
(defrule porneste_dvdplayer
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "porneste dvd"))
    (test (eq ?*dvdplayer* false))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "porneste dvd-playerul")))
    (printout t "porneste dvd-playerul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (bind ?*dvdplayer* true)
    )
(defrule alegedvdo
    ?id<-(actiunicamera (val 1))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "opreste dvd")))
    )
(defrule opreste_dvdplayer
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "opreste dvd"))
    (test (eq ?*dvdplayer* true))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "opreste dvd-playerul")))
    (printout t "opreste dvd-playerul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (bind ?*dvdplayer* false)
     )
(defrule alegetvp
    ?id<-(actiunicamera (val 2))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "porneste tv")))
    )
(defrule porneste_televizor
    (declare (salience 20)) 
    ?id<-(actiune (ora "ora") (descriere "porneste tv"))
    (test (eq ?*televizor* false))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "porneste televizorul")))
    (printout t "porneste televizorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*televizor* true)
    )
(defrule alegetvo
    ?id<-(actiunicamera (val 3))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "opreste tv")))
    )
(defrule opreste_televizor
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "opreste tv"))
    (test (eq ?*televizor* true))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "opreste televizorul")))
    (printout t "opreste televizorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (bind ?*televizor* false)
    )
(defrule alegecalculatorp
    ?id<-(actiunicamera (val 4))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "porneste calculator")))
    )
(defrule porneste_calculator
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "porneste calculator"))
    (test (eq ?*calculator* false))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "porneste calculatorul")))
    (printout t "porneste calculatorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*calculator* true)
    )
(defrule alegecalculatoro
    ?id<-(actiunicamera (val 5))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "opreste calculator")))
    )
(defrule opreste_calculator
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "opreste calculator"))
    (test (eq ?*calculator* true))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "opreste calculatorul")))
    (printout t "opreste calculatorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (bind ?*calculator* false)
    )
(defrule alegeaerp
    ?id<-(actiunicamera (val 6))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "porneste aer conditionat")))
    )
(defrule porneste_aer_conditionat
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "porneste aer conditionat"))
    (test (eq ?*aer_conditionat* false))
    =>
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "porneste aer conditionat")))
    (printout t "porneste aer conditionat la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*aer_conditionat* true)
    )
(defrule alegeaero
    ?id<-(actiunicamera (val 7))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "opreste aer conditionat")))
    )
(defrule opreste_aer_conditionat
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "opreste aer conditionat"))
    (test (eq ?*aer_conditionat* true))
    =>
    (retract ?id)
    (schimba_ora 1)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "opreste aer conditionat")))
    (printout t "opreste aer conditionat la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (bind ?*aer_conditionat* false)
    )
(defrule alegeaspirator
    ?id<-(actiunicamera (val 8))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "aspirator")))
    )
(defrule utilizeaza_aspirator
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "aspirator"))
    (test (neq ?*ultim* aspirator))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* aspirator)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste aspiratorul")))
    (printout t "foloseste aspiratorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 30)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegetv
    ?id<-(actiunicamera (val 9))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "uita tv")))
    )
(defrule uita_tv
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "uita tv"))
    (test (eq ?*televizor* true))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se uita la televizor")))
    (printout t "se uita la televizor"?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 50)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegecalculator
    ?id<-(actiunicamera (val 10))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "sta la calculator")))
    )
(defrule utilizeaza_calculator
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "sta la calculator"))
    (test (eq ?*calculator* true))
    =>
    (bind ?*succes* true)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "foloseste calculatorul")))
    (printout t "foloseste calculatorul la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 50)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegesta
    ?id<-(actiunicamera (val 11))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "sta")))
    )
(defrule sta
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "sta"))
    (test (neq ?*ultim* sta))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* sta)
    (retract ?id)
    (assert (actiune (ora ?*ora* ?*min*) (descriere "sta")))
    (printout t "sta la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 10)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    )
(defrule alegemananca
    ?id<-(actiunibucatarie (val 7))
    =>
    (retract ?id)
    (assert (actiune (ora "ora") (descriere "mananca")))
    )
(defrule mananca
    (declare (salience 20))
    ?id<-(actiune (ora "ora") (descriere "mananca"))
    (test (neq ?*nmancare* 6))
    (test (neq ?*ultim* mananca))
    =>
    (bind ?*succes* true)
    (bind ?*ultim* mananca)
    (retract ?id)   
    (assert (actiune (ora ?*ora* ?*min*) (descriere "se spala la chiuveta")))
    (printout t "se spala la chiuveta la ora "?*ora* ":"?*min* crlf)
    (schimba_ora 5)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (assert (actiune (ora ?*ora* ?*min*) (descriere "mananca")))
    (printout t "mananca la ora "?*ora* ":"?*min* crlf)
    (assert (actiune (ora "ora") (descriere "alege iesire")))
    (schimba_ora 20)
    (bind ?*ora* (ia_ora))
    (bind ?*min* (ia_min))
    (bind ?*nmancare* (+ 1 ?*nmancare*))
    )
(run)
(facts)